package com.xjlsoft.weather.service.impl;

import com.xjlsoft.weather.common.util.DataUtil;
import com.xjlsoft.weather.common.util.DateUtil;
import com.xjlsoft.weather.common.util.StringUtil;
import com.xjlsoft.weather.dto.AerosolDataResponseJson;
import com.xjlsoft.weather.dto.GroundOtherResponseJson;
import com.xjlsoft.weather.dto.GroundPreResponseJson;
import com.xjlsoft.weather.dto.GroundResponseJson;
import com.xjlsoft.weather.dto.GroundTemResponseJson;
import com.xjlsoft.weather.dto.HighDataResponseJson;
import com.xjlsoft.weather.dto.RadiationMinResponseJson;
import com.xjlsoft.weather.dto.RadiationResponseJson;
import com.xjlsoft.weather.entity.AerosolDataJson;
import com.xjlsoft.weather.entity.GroundDataJson;
import com.xjlsoft.weather.entity.GroundOtherJson;
import com.xjlsoft.weather.entity.GroundPreJson;
import com.xjlsoft.weather.entity.GroundTemJson;
import com.xjlsoft.weather.entity.HighDataJson;
import com.xjlsoft.weather.entity.QueryLog;
import com.xjlsoft.weather.entity.RadiationDataJson;
import com.xjlsoft.weather.entity.RadiationMinJson;
import com.xjlsoft.weather.entity.ReponseConstant;
import com.xjlsoft.weather.entity.RequestApi;
import com.xjlsoft.weather.entity.WeatherLog;
import com.xjlsoft.weather.entity.WeatherTask;
import com.xjlsoft.weather.enums.DataSourceEnum;
import com.xjlsoft.weather.enums.RequestApiCodeEnum;
import com.xjlsoft.weather.enums.ResultStausEnum;
import com.xjlsoft.weather.enums.WeatherTaskEnum;
import com.xjlsoft.weather.exception.WeatherException;
import com.xjlsoft.weather.mapper.QueryLogMapper;
import com.xjlsoft.weather.mapper.ReponseConstantMapper;
import com.xjlsoft.weather.mapper.RequestApiMapper;
import com.xjlsoft.weather.mapper.WeatherLogMapper;
import com.xjlsoft.weather.mapper.WeatherTaskMapper;
import com.xjlsoft.weather.service.AerosolDataJsonService;
import com.xjlsoft.weather.service.GroundDataJsonService;
import com.xjlsoft.weather.service.GroundOtherJsonService;
import com.xjlsoft.weather.service.GroundPreJsonService;
import com.xjlsoft.weather.service.GroundTemJsonService;
import com.xjlsoft.weather.service.HighDataJsonService;
import com.xjlsoft.weather.service.RadiationDataJsonService;
import com.xjlsoft.weather.service.RadiationMinJsonService;
import com.xjlsoft.weather.service.WeatherTaskJob;
import com.xjlsoft.weather.service.WeatherTaskService;
import com.xjlsoft.weather.util.TokenUtil;
import com.xjlsoft.weather.util.WeatherDataUtil;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.locks.ReentrantLock;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

/**
 * 定时任务实现
 *
 * @author 码农猿
 */
@Service
public class WeatherTaskServiceImpl extends ServiceImpl<WeatherTaskMapper, WeatherTask> implements WeatherTaskService {
	/**
	 * 日志
	 */
	private static final Logger logger = LoggerFactory.getLogger(WeatherTaskServiceImpl.class);

	@Autowired
	private WeatherTaskMapper weatherTaskMapper;
	
	/**
	 * 可重入锁
	 */
	private ReentrantLock lock = new ReentrantLock();
	/**
	 * 定时任务线程池
	 */
	@Autowired
	private ThreadPoolTaskScheduler threadPoolTaskScheduler;
	/**
	 * 所有定时任务存放Map key :任务 key value:任务实现
	 */
	@Autowired
	@Qualifier(value = "scheduledTaskJobMap")
	private Map<String, WeatherTaskJob> scheduledTaskJobMap;

	/**
	 * 存放已经启动的任务map
	 */
	@SuppressWarnings("rawtypes")
	private Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();

	@Value("${fileSaveDirPrefix}")
	private String fileSaveDirPrefix;// 文件存储根路径

	@Value("${moniTest}")
	private String moniTest; // 是否模拟测试

	@Value("increment")  //
	private String increment;
	@Autowired
	private QueryLogMapper queryLogMapper;

	@Autowired
	private ReponseConstantMapper reponseConstantMapper;

	@Autowired
	private RequestApiMapper requestApiMapper;

	@Autowired
	private GroundDataJsonService groundDataJsonService;

	@Autowired
	private AerosolDataJsonService aerosolDataJsonService;
	
	@Autowired
	private GroundPreJsonService groundPreJsonService;
	
	@Autowired
	private GroundOtherJsonService groundOtherJsonService;

	@Autowired
	private GroundTemJsonService groundTemJsonService;
	
	@Autowired
	private RadiationMinJsonService radiationMinJsonService;
	
	@Autowired
	private HighDataJsonService highDataJsonService;
	
	@Autowired
	private RadiationDataJsonService radiationDataJsonService;
	
	@Autowired
	private WeatherLogMapper weatherLogMapper;

	/**
	 * 所有任务列表
	 */
	@Override
	public List<WeatherTask> taskList() {
		logger.info(">>>>>> 获取任务列表开始 >>>>>> ");
		// 数据库查询所有任务 => 未做分页
		List<WeatherTask> taskBeanList = weatherTaskMapper.selectList(null);
		if (CollectionUtils.isEmpty(taskBeanList)) {
			return new ArrayList<>();
		}

		for (WeatherTask taskBean : taskBeanList) {
			String taskKey = taskBean.getTask_key();

			String result = "0";
			if (this.isStart(taskKey)) {
				result = "1";
				taskBean.setStart_flag_des("正在运行");
			}
			// 是否启动标记处理
			taskBean.setStart_flag(result);

		}
		logger.info(">>>>>> 获取任务列表结束 >>>>>> ");
		return taskBeanList;
	}

	/**
	 * 根据任务key 启动任务
	 */
	@Override
	public Boolean start(String taskKey) {
		logger.info(">>>>>> 启动任务 {} 开始 >>>>>>", taskKey);
		// 添加锁放一个线程启动，防止多人启动多次
		lock.lock();
		logger.info(">>>>>> 添加任务启动锁完毕");
		try {
			// 校验是否已经启动
			if (this.isStart(taskKey)) {
				logger.info(">>>>>> 当前任务已经启动，无需重复启动！");
				return false;
			}
			// 校验任务是否存在
			if (!scheduledTaskJobMap.containsKey(taskKey)) {
				return false;
			}
			// 根据key数据库获取任务配置信息
			WeatherTask scheduledTask = weatherTaskMapper.getByKey(taskKey);
			// 启动任务
			this.doStartTask(scheduledTask);
			
			
			Subject subject = SecurityUtils.getSubject();
			String account=TokenUtil.getAccount((String) subject.getPrincipal());
			WeatherLog wl=new WeatherLog();
			wl.setWeather_log_id(IdWorker.getIdStr());
			wl.setCreate_time(DataUtil.getCurrenTimestamp());
			wl.setWeather_task_id(scheduledTask.getTask_id());
			wl.setUpdate_type("start");
			wl.setUser_id(account);
			wl.setUpdate_des("开启-"+scheduledTask.getTask_desc());
			
			weatherLogMapper.insert(wl);
			
		} finally {
			// 释放锁
			lock.unlock();
			logger.info(">>>>>> 释放任务启动锁完毕");    
		}
		logger.info(">>>>>> 启动任务 {} 结束 >>>>>>", taskKey);
		
		
		
		return true;
	}

	/**
	 * 根据 key 停止任务
	 */
	@Override
	public Boolean stop(String taskKey) {
		logger.info(">>>>>> 进入停止任务 {}  >>>>>>", taskKey);
		// 当前任务实例是否存在
		boolean taskStartFlag = scheduledFutureMap.containsKey(taskKey);
		logger.info(">>>>>> 当前任务实例是否存在 {}", taskStartFlag);
		if (taskStartFlag) {
			// 获取任务实例
			ScheduledFuture scheduledFuture = scheduledFutureMap.get(taskKey);
			// 关闭实例
			scheduledFuture.cancel(true);
			
			
			
			WeatherTask wt = weatherTaskMapper.getByKey(taskKey);
			Subject subject = SecurityUtils.getSubject();
			
			String account=TokenUtil.getAccount((String) subject.getPrincipal());
			WeatherLog wl=new WeatherLog();
			wl.setWeather_log_id(IdWorker.getIdStr());
			wl.setCreate_time(DataUtil.getCurrenTimestamp());
			wl.setWeather_task_id(wt.getTask_id());
			wl.setUpdate_type("stop");
			wl.setUser_id(account);
			wl.setUpdate_des("关闭-"+wt.getTask_desc());
			
			weatherLogMapper.insert(wl);
		}
		logger.info(">>>>>> 结束停止任务 {}  >>>>>>", taskKey);
		
		return taskStartFlag;
	}

	/**
	 * 根据任务key 重启任务
	 */
	@Override
	public Boolean restart(String taskKey) {
		logger.info(">>>>>> 进入重启任务 {}  >>>>>>", taskKey);
		// 先停止
		this.stop(taskKey);
		// 再启动
		return this.start(taskKey);
	}

	/**
	 * 程序启动时初始化 ==> 启动所有正常状态的任务
	 */
	@Override
	public void initAllTask(List<WeatherTask> scheduledTaskBeanList) {
		logger.info("程序启动 ==> 初始化所有任务开始 ！size={}", scheduledTaskBeanList.size());
		if (CollectionUtils.isEmpty(scheduledTaskBeanList)) {
			return;
		}
		for (WeatherTask scheduledTask : scheduledTaskBeanList) {
			// 任务 key
			String taskKey = scheduledTask.getTask_key();
			// 校验是否已经启动
			if (this.isStart(taskKey)) {
				continue;
			}
			// 启动任务
			this.doStartTask(scheduledTask);
		}
		logger.info("程序启动 ==> 初始化所有任务结束 ！size={}", scheduledTaskBeanList.size());
	}

	/**
	 * 执行启动任务
	 */
	private void doStartTask(WeatherTask weatherTask) {
		// 任务key
		String taskKey = weatherTask.getTask_key();
		// 定时表达式
		String taskCron = weatherTask.getTask_cron();
		// 获取需要定时调度的接口
		WeatherTaskJob scheduledTaskJob = scheduledTaskJobMap.get(taskKey);
		logger.info(">>>>>> 任务 [ {} ] ,cron={}", weatherTask.getTask_desc(), taskCron);
		ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(scheduledTaskJob, new Trigger() {
			@Override
			public Date nextExecutionTime(TriggerContext triggerContext) {
				CronTrigger cronTrigger = new CronTrigger(taskCron);
				return cronTrigger.nextExecutionTime(triggerContext);
			}
		});
		// 将启动的任务放入 map
		scheduledFutureMap.put(taskKey, scheduledFuture);
	}

	/**
	 * 任务是否已经启动
	 */
	private Boolean isStart(String taskKey) {
		// 校验是否已经启动
		if (scheduledFutureMap.containsKey(taskKey)) {
			if (!scheduledFutureMap.get(taskKey).isCancelled()) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 打印正在启动的任务
	 */
	@Override
	public String printlnTask() {
		logger.info("当前启动的任务项 size {}", scheduledFutureMap.size());
		String printlnTask = JSON.toJSONString(scheduledFutureMap);
		logger.info("当前启动的任务项 {}", printlnTask);
		return printlnTask;
	}

	@Override
	public Map<String, Object> createQuerylog(RequestApi requestapi, WeatherTask wt) throws Exception {

		
		
		Map<String, Object> map = new HashMap<String, Object>();
		boolean stopTaskFlag = false;
		map.put("stopTaskFlag", stopTaskFlag);
		map.put("initFlag", false);
		
		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimerangeEnd(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());
		if (listDate.size() == 1 && successCount > 0) {

			Date maxdate = listDate.get(0);
			String maxdateStr = DataUtil.formatDate(maxdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByMap(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxdateStr);

			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);

				Timestamp lastTimeEndTemp = ql.getTimerange_end();
				// 上次查询时间末尾
				Date lastTimeEnd = new Date(lastTimeEndTemp.getTime());

				// 获取新的 时间间隔
				Date newStartTime = WeatherDataUtil.afterHour(lastTimeEnd, 1);

				// 现在 最新时间
				Date befor15Date = new Date();
				 
				// 计算xx 天前的时间 
				befor15Date=WeatherDataUtil.afterDate(befor15Date, requestapi.getBefor_day_stop());

				// 如果下一个 开始查询时间 超过 当天（15天前）或 当天日期（15天前）相等 （年月日时分秒 相等即可） 需要停止  抓取历史数据的 定时任务
				if (newStartTime.after(befor15Date) || WeatherDataUtil.sameDate(newStartTime, befor15Date)) {

					/*
					 * boolean flag = this.stop(wt.getTask_key());
					 * 
					 * logger.info(
					 * "=============================================================================="
					 * ); logger.info("==============历史数据统计完毕       关闭定时任务:(" +
					 * wt.getTask_desc() + ") 关闭状态：" + flag); logger.info(
					 * "=============================================================================="
					 * );
					 */
					QueryLog qul = new QueryLog();
					String queryLogId = IdWorker.getIdStr();
					qul.setQuery_log_id(queryLogId);
					qul.setCreate_time(DataUtil.getCurrenTimestamp());
					qul.setRequest_api_id(requestapi.getRequest_api_id());

					qul.setRequest_data_status(ResultStausEnum.ZERO.getValue());
					qul.setRequest_des(ResultStausEnum.ZERO.getMessage() + "上一次成功请求的id:" + ql.getQuery_log_id());

					queryLogMapper.insert(qul);

					stopTaskFlag = true;
					map.put("stopTaskFlag", stopTaskFlag);

					return map;

					/*
					 * boolean flag2 = this.startByWeatherTask(wt);
					 * 
					 * logger.info(
					 * "******************************************************************************"
					 * ); logger.info("***********开启 关联 定时任务:(" +
					 * this.getByWeatherTask(wt).getValue() + ") 开启状态：" +
					 * flag2); logger.info(
					 * "******************************************************************************"
					 * );
					 */
					// 抛出异常 不在运行 下面的代码

					/*
					 * throw new WeatherException(RequestApiCodeEnum.ERROR_9005,
					 * wt.getTask_desc(), wt.getTask_desc(),
					 * ql.getQuery_log_id());
					 */

				}

				if (!(requestapi.getIncrement() > 0)) {
					logger.error("request_api表,未配置 初始间隔天数");
					// 在抛出异常
					throw new WeatherException(RequestApiCodeEnum.ERROR_9003, requestapi.getRequest_api_id());
				}
				Date newEndTime = WeatherDataUtil.afterDate(newStartTime, requestapi.getIncrement());

				// 如果下次 查询 结尾时间    超过15天前             则赋值为15前的 昨天的23时 00 分 00秒
				if (newEndTime.after(befor15Date)) {

					newEndTime = WeatherDataUtil.dateToYesterday23(befor15Date);
				}

				// 准备产生 请求查询数据 进行数据的查询 保存
			

				QueryLog qul = new QueryLog();
				String queryLogId = IdWorker.getIdStr();
				qul.setQuery_log_id(queryLogId);
				qul.setCreate_time(DataUtil.getCurrenTimestamp());
				qul.setRequest_api_id(requestapi.getRequest_api_id());
				qul.setTimerange_start(new Timestamp(newStartTime.getTime()));
				qul.setTimerange_end(new Timestamp(newEndTime.getTime()));

				qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(newStartTime, newEndTime));

				// 开始 时间字符串 结束时间字符串
				qul.setTimerangeStartStr(DateUtil.DateToString(newStartTime, "yyyyMMddHHmmss"));
				qul.setTimerangeEndStr(DateUtil.DateToString(newEndTime, "yyyyMMddHHmmss"));

				int request = queryLogMapper.insert(qul);
				if (request > 0) {
					map.put("querylog", qul);
					return map;
				} else {
					logger.error(" 请求数据(QueryLog)保存失败");
					throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
				}

			} else {
				logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
			}
		} else {
			// 需要初始化数据
			// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存
			// 获取初始化参数
			Map<String, Object> mp = this.inintCreateQuerylog(requestapi, wt);
			return mp;
		}

	}

	@Override
	public Map<String, Object> inintCreateQuerylog(RequestApi requestapi, WeatherTask wt) throws Exception {

		Map<String, Object> map = new HashMap<String, Object>();
		map.put("initFlag", true);
		map.put("stopTaskFlag",false);
		// 需要初始化数据
		// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存

		// 获取初始化参数
		RequestApi reqapi = requestApiMapper.selectById(requestapi.getRequest_api_id());
		if (reqapi == null) {
			throw new WeatherException(RequestApiCodeEnum.ERROR_9001, requestapi.getRequest_api_id());
		}
		QueryLog qul = new QueryLog();
		String queryLogId = IdWorker.getIdStr();
		qul.setQuery_log_id(queryLogId);

		qul.setCreate_time(DataUtil.getCurrenTimestamp());

		qul.setRequest_api_id(requestapi.getRequest_api_id());
		qul.setTimerange_start(reqapi.getTime_start());
		qul.setTimerange_end(reqapi.getTime_end());
		qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(reqapi.getTime_start(), reqapi.getTime_end()));

		qul.setTimerangeStartStr(WeatherDataUtil.getTimestampStr(reqapi.getTime_start()));
		qul.setTimerangeEndStr(WeatherDataUtil.getTimestampStr(reqapi.getTime_end()));

		int request = queryLogMapper.insert(qul);

		if (request > 0) {
			map.put("querylog", qul);
			return map;
		} else {
			logger.error(" 初始化Querylog数据保存失败");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9002, requestapi.getRequest_api_id());
		}

	}

	@Override
	public void saveGroundDataJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {

		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "groundData" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\地面小时数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}

		try {
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				GroundResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 地面数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int gdCount = 0;

					// 取得实际数据
					List<GroundDataJson> listgd = jsonObject.getGroundDataJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						gdCount = listgd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(gdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (gdCount > 0) {
						// 循环加工数据
						Iterator<GroundDataJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							GroundDataJson gd = iter.next();
							// 设置主键id
							gd.setGround_data_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), null);
							gd.setData_time(filedate);

							// 数据保存时间
							gd.setCreate_time(date);
						}
						// 保存数据
						boolean resultflag = groundDataJsonService.saveList(listgd);
						System.out.println("地面数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}

				} else {
					// 请求接口成功的  但是 返回失败的处理

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有地面数据");
				}
				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
			
		} catch (IOException e) {
			logger.error(" 地面数据 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		

	}

	@Override
	public void saveAerosolDataJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "aerosolData" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\气溶胶数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
			
			// FileReader fileReader = new
			// FileReader("F:\\zbl\\气象局前期资料\\气溶胶数据.txt");
			// String result = StringUtil.getJsonTxt(fileReader);
		} else {
			
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}


		try {
			// 保存数据 到 txt 文档中 自动建文件外两层目录
			if( result !=null){
				
				//保存数据到磁盘
				WeatherDataUtil.saveResultTxtFile(result, file);
				
				
				AerosolDataResponseJson jsonObject = JSONObject.parseObject(result,
						new TypeReference<AerosolDataResponseJson>() {
						});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int adCount = 0;

					// 取得实际数据
					List<AerosolDataJson> listad = jsonObject.getAerosolDataJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						adCount = listad.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());
					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					

					// 如果查询成功但是 没有数据 则 填入对应的提示
					if (RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
						ql.setRequest_des(RequestApiCodeEnum.SUCCESS_FALSE.getMessage());
					}

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(adCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (adCount > 0) {
						// 循环加工数据
						Iterator<AerosolDataJson> iter = listad.iterator();
						while (iter.hasNext()) {
							AerosolDataJson gd = iter.next();
							// 设置主键id
							gd.setAeroso_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());
							// 数据保存时间
							gd.setCreate_time(date);

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);
						}
						// 保存数据
						boolean resultflag = aerosolDataJsonService.saveList(listad);
						System.out.println("====气溶胶数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}
				} else {
					// 请求

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());

					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有气溶胶数据");
				}
				
			}else{        //请求结果   为null的处理
				
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
		} catch (IOException e) {
			logger.error(" 气溶胶数据 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		

	}

	@Override
	public void saveHighDataJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		// 返回高空数据的 文件路径
		String filepath = "highData" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		// FileReader fileReader = new FileReader("F:\\zbl\\气象局前期资料\\高空数据.txt");
		// String result = StringUtil.getJsonTxt(fileReader);
		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\高空数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestTimesDataApi(requestapi, querylog);
		}

		try {
			
			
			if(result!=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				
				
				HighDataResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<HighDataResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();

				// 返回两种状态 查询成功有数据 查询成功无数据
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int hdCount = 0;

					// 取得实际数据
					List<HighDataJson> listhd = jsonObject.getHighDataJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						hdCount = listhd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(hdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					List<HighDataJson> listgd = jsonObject.getHighDataJson();
					Timestamp date = DataUtil.getCurrenTimestamp();

					if (hdCount > 0) {
						// 循环加工数据
						Iterator<HighDataJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							HighDataJson gd = iter.next();
							// 设置主键id
							gd.setHigh_data_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());
							// 数据保存时间
							gd.setCreate_time(date);

							// 资料时间
							Timestamp date1 = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(), gd.getHour(),
									gd.getMin());
							gd.setData_time(date1);

							Timestamp date2 = WeatherDataUtil.getTimestamp(gd.getYear_data(), gd.getMon_data(),
									gd.getDay_data(), gd.getHour_data(), null);
							gd.setMeasure_time(date2);
							gd.setData_source(DataSourceEnum.JianGeTask.getValue());
						}
						// 保存数据
						boolean resultflag = highDataJsonService.saveList(listgd);
						System.out.println("====高空数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}
				} else {
					// 请求

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());

					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有高空数据");
				}

				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
		} catch (IOException e) {
			logger.error(" 高空数据 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		
	}

	@Override
	public void saveArdiationDataJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "radiationData" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		// FileReader fileReader = new FileReader("F:\\zbl\\气象局前期资料\\辐射数据.txt");
		// String result = StringUtil.getJsonTxt(fileReader);
		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\辐射数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}
		try {
			
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				
				RadiationResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<RadiationResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				// 查询成功 有数据 和无数据 的处理
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int rdCount = 0;

					// 取得实际数据
					List<RadiationDataJson> listrd = jsonObject.getRadiationDataJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						rdCount = listrd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(rdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					// List<RadiationData> listgd = jsonObject.getRadiationData();
					Timestamp date = DataUtil.getCurrenTimestamp();

					if (rdCount > 0) {
						// 循环加工数据
						Iterator<RadiationDataJson> iter = listrd.iterator();
						while (iter.hasNext()) {
							RadiationDataJson gd = iter.next();
							// 设置主键id
							gd.setRadiation_data_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());
							// 数据保存时间
							gd.setCreate_time(date);

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);
						}
						// 保存数据
						boolean resultflag = radiationDataJsonService.saveList(listrd);
						System.out.println("====辐射数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}
				} else {
					// 请求
					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());

					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有辐射数据");
				}

			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
				
			}
		} catch (IOException e) {
			logger.error(" 辐射数据 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		
	}

	@Override
	public Map<String, Object> createHighDataQuerylog(RequestApi requestapi, WeatherTask wt) throws Exception {
		
		Map<String, Object> map = new HashMap<String, Object>();

		boolean stopTaskFlag = false;
		map.put("initFlag", false);
		map.put("stopTaskFlag", stopTaskFlag);

		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimerangeEnd(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		if (listDate.size() == 1 && successCount > 0) {

			Date maxTimesdate = listDate.get(0);
			String maxTimesStr = DataUtil.formatDate(maxTimesdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByadt(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxTimesStr);

			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);

				// 获取到上一次 的查询 成功  最后 一个 时间点的时间
				Timestamp timesStart = ql.getTimerange_end();

				Timestamp startDate=WeatherDataUtil.afterHour(timesStart, 1);
				Timestamp endDate=startDate;
				// 时间个数 例如 为2 表示两个个时间
				int increment = requestapi.getIncrement();

				if (!(increment > 0)) {
					logger.error(" 高空数据requestapi 未配置 时间时间个数，默认赋值为2,即每次查询两个时间的数据");
					increment = 2;
				}

				// 保存时间 下一步 循环查询querylog数据
				List<String> listTimes = new ArrayList<String>();


				Date befor15Date = new Date();
				
				// 计算xx 天前的时间   到距今 15天的 时间  不在抓取历史数据
				befor15Date=WeatherDataUtil.afterDate(befor15Date, requestapi.getBefor_day_stop());
				for (int i = 0; i < increment; i++) {

					Timestamp nextTime = WeatherDataUtil.afterHour(timesStart, 1);

					String nextTimeStrs=DateUtil.DateToString(nextTime, "yyyyMMddHHmmss");
					// 如果下一个 时间 超过今天 或 下一个 时间的年月日 =今天的年月日
					// 需要 返回停止定时任务 标识
					if (nextTime.after(befor15Date) || WeatherDataUtil.sameDate(nextTime, befor15Date)) {
						stopTaskFlag = true;
						map.put("stopTaskFlag", stopTaskFlag);
						// 跳出 for循环
						break;

					}

					listTimes.add(nextTimeStrs);
					timesStart = nextTime;
					endDate=nextTime;
				}

				if (listTimes.size() > 0) {
					
						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());
                        qul.setTimerange_start(startDate);
                        qul.setTimerange_end(endDate);
						qul.setTimes(WeatherDataUtil.getTimesStr(listTimes));
						qul.setTimesStr(WeatherDataUtil.getTimesStr(listTimes));

						qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(startDate, endDate));
						int requsultTemp = queryLogMapper.insert(qul);
						
						if (requsultTemp > 0) {
							map.put("querylog", qul);
							return map;
						}
						else {
							logger.error(" 请求数据(QueryLog)保存失败");
							throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
						}
				} else {
					return null;
				}

			} else {
				logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
			}
		} else {
			// 需要初始化数据
			// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存
			// 获取初始化参数
			Map<String, Object> mp = this.inintHighDataCreateQuerylog(requestapi, wt);
			return mp;
		}

		/*Map<String, Object> map = new HashMap<String, Object>();

		boolean stopTaskFlag = false;
		map.put("initFlag", false);
		map.put("stopTaskFlag", stopTaskFlag);

		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimes(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		if (listDate.size() == 1 && successCount > 0) {

			Date maxTimesdate = listDate.get(0);
			String maxTimesStr = DataUtil.formatDate(maxTimesdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByadt(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxTimesStr);

			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);

				// 获取到上一次 的查询 成功时间
				Timestamp timesStart = ql.getTimes();

				// 时间个数 例如 为2 表示两个个时间
				int increment = requestapi.getIncrement();

				if (!(increment > 0)) {
					logger.error(" 高空数据requestapi 未配置 时间时间个数，默认赋值为1,即每次查询两个时间的数据");
					increment = 1;
				}

				// 保存时间 下一步 循环查询querylog数据
				List<Timestamp> listTimes = new ArrayList<Timestamp>();

				List<QueryLog> listqlr = new ArrayList<QueryLog>();

				Date nowDate = new Date();
				for (int i = 0; i < increment; i++) {

					Timestamp nextTime = WeatherDataUtil.calculateEndDate(timesStart, 1);

					// 如果下一个 时间 超过今天 或 下一个 时间的年月日 =今天的年月日
					// 需要 返回停止定时任务 标识
					if (nextTime.after(nowDate) || WeatherDataUtil.sameDate(nextTime, nowDate)) {

						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());

						qul.setRequest_data_status(ResultStausEnum.ZERO.getValue());
						qul.setRequest_des(ResultStausEnum.ZERO.getMessage() + "上一次成功请求的id:" + ql.getQuery_log_id());

						queryLogMapper.insert(qul);

						stopTaskFlag = true;
						map.put("stopTaskFlag", stopTaskFlag);

						// 跳出 for循环
						break;

					}

					listTimes.add(nextTime);
					timesStart = nextTime;
				}

				int request = 0;
				if (listTimes.size() > 0) {

					Iterator<Timestamp> iter = listTimes.iterator();
					while (iter.hasNext()) {

						Timestamp time = iter.next();

						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());

						qul.setTimes(time);
						qul.setTimesStr(WeatherDataUtil.getTimestampStr(time));

						int requsultTemp = queryLogMapper.insert(qul);
						request = request + requsultTemp;
						if (requsultTemp > 0) {
							listqlr.add(qul);
						}

					}
				} else {
					return null;
				}

				if (request > 0) {
					map.put("querylog", listqlr);
					return map;
				} else {
					logger.error(" 请求数据(QueryLog)保存失败");
					throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
				}

			} else {
				logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
			}
		} else {
			// 需要初始化数据
			// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存
			// 获取初始化参数
			Map<String, Object> mp = this.inintHighDataCreateQuerylog(requestapi, wt);
			return mp;
		}*/

	}

	@Override
	public Map<String, Object> inintHighDataCreateQuerylog(RequestApi requestapi, WeatherTask wt) throws Exception {
		Map<String, Object> map = new HashMap<String, Object>();

		map.put("initFlag", true);
		map.put("stopTaskFlag",false);
		// 需要初始化数据
		// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存

		// 获取初始化参数
		RequestApi reqapi = requestApiMapper.selectById(requestapi.getRequest_api_id());
		if (reqapi == null) {
			throw new WeatherException(RequestApiCodeEnum.ERROR_9001, requestapi.getRequest_api_id());
		}
		QueryLog qul = new QueryLog();
		String queryLogId = IdWorker.getIdStr();
		qul.setQuery_log_id(queryLogId);

		qul.setCreate_time(DataUtil.getCurrenTimestamp());

		qul.setRequest_api_id(requestapi.getRequest_api_id());

		// 查询时间 初始化 一个小时的量
		qul.setTimes(WeatherDataUtil.getTimestampStr(reqapi.getTimes_init()));
		qul.setTimesStr(WeatherDataUtil.getTimestampStr(reqapi.getTimes_init()));

		qul.setTimerange_start(reqapi.getTime_start());
		qul.setTimerange_end(reqapi.getTime_end());
		
		qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(reqapi.getTimes_init(), reqapi.getTimes_init()));
		
		
		
		int request = queryLogMapper.insert(qul);

		if (request > 0) {
			map.put("querylog", qul);
			return map;
		} else {
			logger.error(" 初始化Querylog数据保存失败");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9002, requestapi.getRequest_api_id());
		}

	}

	@Override
	public QueryLog createQuerylogTimin(RequestApi requestapi, WeatherTask wt) throws Exception {

		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimerangeEnd(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());
		if (listDate.size() == 1 && successCount > 0) {

			Date maxdate = listDate.get(0);
			String maxdateStr = DataUtil.formatDate(maxdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByMap(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxdateStr);

			// if (listql.size() == 1) {

			// 获取的 最后一次成功的 querylog数据
			QueryLog ql = listql.get(0);

			Timestamp lastTimeEndTemp = ql.getTimerange_end();
			// 上次查询时间末尾
			Date lastTimeEnd = new Date(lastTimeEndTemp.getTime());

			// 获取新的 开始时间  一个小时后的时间
			Date newStartTime = WeatherDataUtil.afterHour(lastTimeEnd, 1);

			// 现在 最新时间
			Date nowDate = new Date();

			// 如果下一个 开始查询时间 超过 未来 或 日期相等 （年月日时分秒 相等即可）本次不产生   查询日期条件
			if (newStartTime.after(nowDate) || WeatherDataUtil.sameDate(newStartTime, nowDate)) {

				logger.info("===========今日无新数据 需要抓取  =========上一次数据请求成功信息：querylogid=" + ql.getQuery_log_id()
						+ ",查询时间字符串:" + ql.getTimerangeStartStr() + "-" + ql.getTimerangeEndStr());

				QueryLog qul = new QueryLog();
				String queryLogId = IdWorker.getIdStr();
				qul.setQuery_log_id(queryLogId);
				qul.setCreate_time(DataUtil.getCurrenTimestamp());
				qul.setRequest_api_id(requestapi.getRequest_api_id());

				qul.setRequest_data_status(ResultStausEnum.TWO.getValue());
				qul.setRequest_des(ResultStausEnum.TWO.getMessage() + "上一次成功请求的id:" + ql.getQuery_log_id());

				queryLogMapper.insert(qul);

				// 抛出异常 不在运行 下面的代码

				/*throw new WeatherException(RequestApiCodeEnum.ERROR_9006, wt.getTask_key(), wt.getTask_id(),
						ql.getQuery_log_id(), ql.getTimeRangeStr(), ql.getTimesStr());*/
				return null;

			}

			if (!(requestapi.getIncrement() > 0)) {
				logger.error("request_api表,未配置 初始间隔天数,程序自动设置为5");
				requestapi.setIncrement(5);
			}
			
			
			//计算 当天的 昨天的23时0分0秒时间
			Date yesterday23=WeatherDataUtil.dateToYesterday23(nowDate);
			// 计算  下一个 查询结尾时间
			//Date newEndTime = WeatherDataUtil.afterDate(newStartTime, requestapi.getIncrement());

			System.out.println("yesterday23 昨天的23点时间" + DataUtil.formatDate(yesterday23, "yyyyMMddHHmmss"));
			System.out.println("nowDate" + DataUtil.formatDate(nowDate, "yyyyMMddHHmmss"));
			// 如果下次 查询 结尾时间 是未来 则赋值为 昨天的23时 00 分 00秒
			if (yesterday23.after(nowDate)) {

				yesterday23 = WeatherDataUtil.yesterday23();
			}
			
			
			//-===============开始探查  新的开始时间   到  昨天的23点 时间 是否新数据   如果没有 在向接口请求数据   
			
			//计算下一个 有数据的时间点
			
			Date endTime=WeatherDataUtil.getLastEndTime(newStartTime, yesterday23, requestapi);
			logger.info("--  下个有数据的末尾时间点："+DataUtil.formatDate(endTime, "yyyyMMddHHmmss"));
            if(endTime ==null){
            	logger.info("---------未查询到下一个 有数据的  时间 末位点-----------");
            	return null;
            }
            
          //-===============探查结束  新的开始时间   到  昨天的23点 时间 是否新数据   如果没有 在向接口请求数据   
            
            
            
			QueryLog qul = new QueryLog();
			String queryLogId = IdWorker.getIdStr();
			qul.setQuery_log_id(queryLogId);
			qul.setCreate_time(DataUtil.getCurrenTimestamp());
			qul.setRequest_api_id(requestapi.getRequest_api_id());
			qul.setTimerange_start(new Timestamp(newStartTime.getTime()));
			qul.setTimerange_end(new Timestamp(endTime.getTime()));

			qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(newStartTime, endTime));

			// 开始 时间字符串 结束时间字符串
			qul.setTimerangeStartStr(DateUtil.DateToString(newStartTime, "yyyyMMddHHmmss"));
			qul.setTimerangeEndStr(DateUtil.DateToString(endTime, "yyyyMMddHHmmss"));

			int request = queryLogMapper.insert(qul);
			if (request > 0) {
				// map.put("querylog", qul);
				return qul;
			} else {
				logger.error(" 请求数据(QueryLog)保存失败");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9007,
						"任务名称：" + wt.getTask_desc() + "任务id:" + wt.getTask_desc());
			}

		} else {
			logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id(),
					"任务名称：" + wt.getTask_desc() + "任务id:" + wt.getTask_desc());
		}
	}

	@Override
	public QueryLog createHighDataQuerylogTimin(RequestApi requestapi, WeatherTask wt) throws Exception {

		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimes(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());
		if (listDate.size() == 1 && successCount > 0) {

			Date maxTimesdate = listDate.get(0);
			String maxTimesStr = DataUtil.formatDate(maxTimesdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByadt(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxTimesStr);
			QueryLog beforQl=null;
			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);
				beforQl=ql;
				// 获取到上一次 的查询 成功时间
				Timestamp timesStart = ql.getTimerange_end();

				Timestamp startDate=WeatherDataUtil.afterHour(timesStart, 1);
				Timestamp endDate=startDate;
				// 时间个数 例如 为2 表示 查询两个时间点的数据 格式： 20200730000000,20200731000000
				int increment = requestapi.getIncrement();

				if (!(increment > 0)) {
					logger.error(" 高空数据requestapi 未配置 时间时间个数，默认赋值为1,即每次查一个时间点的数据");
					increment = 1;
				}

				// 保存时间 下一步 循环查询querylog数据
				List<String> listTimes = new ArrayList<String>();

				
				Timestamp startTime=WeatherDataUtil.afterHour(timesStart, 1);
				
				//昨天的  0时0分0秒时间
				Date endTime=WeatherDataUtil.yesterday00();
				
				//下一个 有数据的 远端 时间点
				Date  lastEndTime=WeatherDataUtil.getLastEndTimeHighData(new Date(startTime.getTime()), endTime, requestapi);
				
				if(lastEndTime ==null){
					logger.info(" ===  不存在下一个 有数据的时间点   =============");
					return null;
				}
				
				
				
				// 加工时间条件 将时间条件 放集合里
				while(true){
					String nextTimeStrs=DateUtil.DateToString(startTime, "yyyyMMddHHmmss");
					listTimes.add(nextTimeStrs);
					startTime =WeatherDataUtil.afterHour(timesStart, 1);
					if((new Date(startTime.getTime())).after(lastEndTime) || WeatherDataUtil.sameDate(new Date(startTime.getTime()), lastEndTime)){
						break;
					}
				}

				

				if (listTimes.size() > 0) {

						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());

						qul.setTimerange_start(startDate);
                        qul.setTimerange_end(endDate);
						qul.setTimes(WeatherDataUtil.getTimesStr(listTimes));
						qul.setTimesStr(WeatherDataUtil.getTimesStr(listTimes));
						
						qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(startDate,endDate));

						int requsultTemp = queryLogMapper.insert(qul);
						if (requsultTemp > 0) {
							return qul;
						}else {
							logger.error(" 请求数据(QueryLog)保存失败");
							throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
						}

					}
				} else {

					logger.info("===========今日无新数据 需要抓取  =========上一次数据请求成功信息：querylogid=" + beforQl.getQuery_log_id()
							+ ",查询时间:" + beforQl.getTimerangeStartStr() + "-" + beforQl.getTimerangeEndStr());

					QueryLog qul = new QueryLog();
					String queryLogId = IdWorker.getIdStr();
					qul.setQuery_log_id(queryLogId);
					qul.setCreate_time(DataUtil.getCurrenTimestamp());
					qul.setRequest_api_id(requestapi.getRequest_api_id());

					qul.setRequest_data_status(ResultStausEnum.TWO.getValue());
					qul.setRequest_des(ResultStausEnum.TWO.getMessage() + "上一次成功请求的id:" + beforQl.getQuery_log_id());

					queryLogMapper.insert(qul);

					return null;
				}

		} else {
			logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
		}
		return null;

	}

	@Override
	public Boolean startByWeatherTask(WeatherTask wt) {

		String taskKey = "";
		String taskKeyTemp = wt.getTask_key();

		if (WeatherTaskEnum.GroundDataTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.GroundDataTaskTimin.getValue();

		} else if (WeatherTaskEnum.AerosolDataTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.AerosolDataTaskTimin.getValue();
		} else if (WeatherTaskEnum.HighDataTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.HighDataTaskTimin.getValue();
		} else if (WeatherTaskEnum.RadiationTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.RadiationTaskTimin.getValue();
		}
		else if (WeatherTaskEnum.GroundPreTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.GroundPreTaskTimin.getValue();
		}
		else if (WeatherTaskEnum.GroundOtherTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.GroundDataTaskTimin.getValue();
		}
		else if (WeatherTaskEnum.GroundTemTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.GroundTemTaskTimin.getValue();
		}
		else if (WeatherTaskEnum.RadiationMinTask.getValue().equals(taskKeyTemp)) {
			taskKey = WeatherTaskEnum.RadiationMinTaskTimin.getValue();
		}

		logger.info("==================启动 关联 定时 任务 {} 开始 >>>>>>", taskKey);
		// 添加锁放一个线程启动，防止多人启动多次
		lock.lock();
		logger.info(">>>>>> 添加任务启动锁完毕");
		try {
			// 校验是否已经启动
			if (this.isStart(taskKey)) {
				logger.info(">>>>>> 当前任务已经启动，无需重复启动！");
				return false;
			}
			// 校验任务是否存在
			if (!scheduledTaskJobMap.containsKey(taskKey)) {
				return false;
			}
			// 根据key数据库获取任务配置信息
			WeatherTask scheduledTask = weatherTaskMapper.getByKey(taskKey);
			// 启动任务
			this.doStartTask(scheduledTask);
		} finally {
			// 释放锁
			lock.unlock();
			logger.info(">>>>>> 释放任务启动锁完毕");
		}
		logger.info("==================启动 关联 定时 任务 {} 结束 >>>>>>", taskKey);
		return true;
	}

	@Override
	public WeatherTaskEnum getByWeatherTask(WeatherTask wt) {
		WeatherTaskEnum wtTemp = null;
		String taskKeyTemp = wt.getTask_key();

		if (WeatherTaskEnum.GroundDataTask.getValue().equals(taskKeyTemp)) {
			wtTemp = WeatherTaskEnum.GroundDataTaskTimin;

		} else if (WeatherTaskEnum.AerosolDataTask.getValue().equals(taskKeyTemp)) {
			wtTemp = WeatherTaskEnum.AerosolDataTaskTimin;
		} else if (WeatherTaskEnum.HighDataTask.getValue().equals(taskKeyTemp)) {
			wtTemp = WeatherTaskEnum.HighDataTaskTimin;
		} else if (WeatherTaskEnum.RadiationTask.getValue().equals(taskKeyTemp)) {
			wtTemp = WeatherTaskEnum.RadiationTaskTimin;
		}
		return wtTemp;
	}

	@Override
	public Map<String, Object> createQuerylogMinData(RequestApi requestapi, WeatherTask wt) throws Exception {
		
		Map<String, Object> map = new HashMap<String, Object>();

		boolean stopTaskFlag = false;
		map.put("initFlag", false);
		map.put("stopTaskFlag", stopTaskFlag);

		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimes(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		if (listDate.size() == 1 && successCount > 0) {

			Date maxTimesdate = listDate.get(0);
			String maxTimesStr = DataUtil.formatDate(maxTimesdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByadt(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxTimesStr);

			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);

				// 获取到上一次 的查询 成功时间
				Timestamp timesStart = ql.getTimerange_end();

				// 时间个数 例如 为2 表示两个个时间
				int increment = requestapi.getIncrement();

				if (!(increment > 0)) {
					logger.error(" 辐射分钟 数据requestapi 未配置 时间时间个数，默认赋值为60,即每次查询两个时间的数据");
					increment = 60;
				}

				// 保存时间 下一步 循环查询querylog数据
				List<Timestamp> listTimes = new ArrayList<Timestamp>();

				List<QueryLog> listqlr = new ArrayList<QueryLog>();

				Date nowDate = new Date();
				for (int i = 0; i < increment; i++) {

					Timestamp nextTime = WeatherDataUtil.afterMin(timesStart, 1);

					// 如果下一个 时间 超过今天 或 下一个 时间的年月日 =今天的年月日
					// 需要 返回停止定时任务 标识
					if (nextTime.after(nowDate) || WeatherDataUtil.sameDate(nextTime, nowDate)) {

						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());

						qul.setRequest_data_status(ResultStausEnum.ZERO.getValue());
						qul.setRequest_des(ResultStausEnum.ZERO.getMessage() + "上一次成功请求的id:" + ql.getQuery_log_id());

						queryLogMapper.insert(qul);

						stopTaskFlag = true;
						map.put("stopTaskFlag", stopTaskFlag);

						// 跳出 for循环
						break;

					}

					listTimes.add(nextTime);
					timesStart = nextTime;
				}

				int request = 0;
				if (listTimes.size() > 0) {

					Iterator<Timestamp> iter = listTimes.iterator();
					while (iter.hasNext()) {

						Timestamp time = iter.next();

						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());

						qul.setTimes(null);
						qul.setTimesStr(WeatherDataUtil.getTimestampStr(time));

						int requsultTemp = queryLogMapper.insert(qul);
						request = request + requsultTemp;
						if (requsultTemp > 0) {
							listqlr.add(qul);
						}

					}
				} else {
					return null;
				}

				if (request > 0) {
					map.put("querylog", listqlr);
					return map;
				} else {
					logger.error(" 请求数据(QueryLog)保存失败");
					throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
				}

			} else {
				logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
			}
		} else {
			// 需要初始化数据
			// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存
			// 获取初始化参数
			Map<String, Object> mp = this.inintHighDataCreateQuerylog(requestapi, wt);
			return mp;
		}
		
	}

	@Override
	public void saveGroundProJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "groundPre" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\groundPre数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}

		try {
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				GroundPreResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundPreResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 地面数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int gdCount = 0;

					// 取得实际数据
					List<GroundPreJson> listgd = jsonObject.getGroundPreJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						gdCount = listgd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(gdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (gdCount > 0) {
						// 循环加工数据
						Iterator<GroundPreJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							GroundPreJson gd = iter.next();
							// 设置主键id
							gd.setGround_pre_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);

							// 数据保存时间
							gd.setCreate_time(date);
						}
						// 保存数据
						boolean resultflag = groundPreJsonService.saveList(listgd);
						System.out.println("数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}

				} else {
					// 请求接口成功的  但是 返回失败的处理

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有地面数据");
				}
				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
			
		} catch (IOException e) {
			logger.error(" 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

	}

	@Override
	public QueryLog createQuerylogTiminMinData(RequestApi requestapi, WeatherTask wt) throws Exception {
		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimerangeEnd(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());
		if (listDate.size() == 1 && successCount > 0) {

			Date maxdate = listDate.get(0);
			String maxdateStr = DataUtil.formatDate(maxdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByMap(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxdateStr);

			// if (listql.size() == 1) {

			// 获取的 最后一次成功的 querylog数据
			QueryLog ql = listql.get(0);

			Timestamp lastTimeEndTemp = ql.getTimerange_end();
			// 上次查询时间末尾
			Date lastTimeEnd = new Date(lastTimeEndTemp.getTime());

			// 获取新的 时间间隔
			Date newStartTime = WeatherDataUtil.afterMin(lastTimeEnd, 1);

			// 现在 最新时间
			Date nowDate = new Date();

			// 如果下一个 开始查询时间 超过 未来 或 日期相等 （年月日时分秒 相等即可）本次不产生   查询日期条件
			if (newStartTime.after(nowDate) || WeatherDataUtil.sameDate(newStartTime, nowDate)) {

				logger.info("===========今日无新数据 需要抓取  =========上一次数据请求成功信息：querylogid=" + ql.getQuery_log_id()
						+ ",查询时间字符串:" + ql.getTimerangeStartStr() + "-" + ql.getTimerangeEndStr());

				QueryLog qul = new QueryLog();
				String queryLogId = IdWorker.getIdStr();
				qul.setQuery_log_id(queryLogId);
				qul.setCreate_time(DataUtil.getCurrenTimestamp());
				qul.setRequest_api_id(requestapi.getRequest_api_id());

				qul.setRequest_data_status(ResultStausEnum.TWO.getValue());
				qul.setRequest_des(ResultStausEnum.TWO.getMessage() + "上一次成功请求的id:" + ql.getQuery_log_id());

				queryLogMapper.insert(qul);

				// 抛出异常 不在运行 下面的代码

				/*throw new WeatherException(RequestApiCodeEnum.ERROR_9006, wt.getTask_key(), wt.getTask_id(),
						ql.getQuery_log_id(), ql.getTimeRangeStr(), ql.getTimesStr());*/
				return null;

			}

			if (!(requestapi.getIncrement() > 0)) {
				logger.error("request_api表,未配置 初始间隔天数,程序自动设置为1");
				requestapi.setIncrement(1);
			}
			
			
			//计算 当天的 昨天的23时590分0秒时间
			Date yesterday2359=WeatherDataUtil.dateToYesterday2359(nowDate);
			// 计算  下一个 查询结尾时间
			//Date newEndTime = WeatherDataUtil.afterDate(newStartTime, requestapi.getIncrement());

			System.out.println("yesterday23 昨天的23点59时间" + DataUtil.formatDate(yesterday2359, "yyyyMMddHHmmss"));
			System.out.println("nowDate" + DataUtil.formatDate(nowDate, "yyyyMMddHHmmss"));
			// 如果下次 查询 结尾时间 是未来 则赋值为 昨天的23时 00 分 00秒
			if (yesterday2359.after(nowDate)) {

				yesterday2359 = WeatherDataUtil.yesterday23();
			}
			
			
			//-===============开始探查  新的开始时间   到  昨天的23点 时间 是否新数据   如果没有 在向接口请求数据   
			
			//计算下一个 有数据的时间点
			
			Date endTime=WeatherDataUtil.getLastEndTimeMinData(newStartTime, yesterday2359, requestapi);
			logger.info("--  下个有数据的末尾时间点："+DataUtil.formatDate(endTime, "yyyyMMddHHmmss"));
            if(endTime ==null){
            	logger.info("---------未查询到下一个 有数据的  时间 末位点-----------");
            	return null;
            }
            
          //-===============探查结束  新的开始时间   到  昨天的23点 时间 是否新数据   如果没有 在向接口请求数据   
            
            
            
			QueryLog qul = new QueryLog();
			String queryLogId = IdWorker.getIdStr();
			qul.setQuery_log_id(queryLogId);
			qul.setCreate_time(DataUtil.getCurrenTimestamp());
			qul.setRequest_api_id(requestapi.getRequest_api_id());
			qul.setTimerange_start(new Timestamp(newStartTime.getTime()));
			qul.setTimerange_end(new Timestamp(endTime.getTime()));

			qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(newStartTime, endTime));

			// 开始 时间字符串 结束时间字符串
			qul.setTimerangeStartStr(DateUtil.DateToString(newStartTime, "yyyyMMddHHmmss"));
			qul.setTimerangeEndStr(DateUtil.DateToString(endTime, "yyyyMMddHHmmss"));

			int request = queryLogMapper.insert(qul);
			if (request > 0) {
				// map.put("querylog", qul);
				return qul;
			} else {
				logger.error(" 请求数据(QueryLog)保存失败");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9007,
						"任务名称：" + wt.getTask_desc() + "任务id:" + wt.getTask_desc());
			}

		} else {
			logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id(),
					"任务名称：" + wt.getTask_desc() + "任务id:" + wt.getTask_desc());
		}
	}

	@Override
	public void saveGroundPreJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "groundData" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\groundPre数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}

		try {
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				GroundPreResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundPreResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 地面数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int gdCount = 0;

					// 取得实际数据
					List<GroundPreJson> listgd = jsonObject.getGroundPreJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						gdCount = listgd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(gdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (gdCount > 0) {
						// 循环加工数据
						Iterator<GroundPreJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							GroundPreJson gd = iter.next();
							// 设置主键id
							gd.setGround_pre_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);

							// 数据保存时间
							gd.setCreate_time(date);
						}
						// 保存数据
						boolean resultflag = groundPreJsonService.saveList(listgd);
						System.out.println("地面数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}

				} else {
					// 请求接口成功的  但是 返回失败的处理

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有地面数据");
				}
				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
			
		} catch (IOException e) {
			logger.error(" 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}
	}

	@Override
	public void saveGroundOtherJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "groundOther" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\groundOther数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}

		try {
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				GroundOtherResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundOtherResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 地面数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int gdCount = 0;

					// 取得实际数据
					List<GroundOtherJson> listgd = jsonObject.getGroundOtherJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						gdCount = listgd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(gdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (gdCount > 0) {
						// 循环加工数据
						Iterator<GroundOtherJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							GroundOtherJson gd = iter.next();
							// 设置主键id
							gd.setGround_other_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);

							// 数据保存时间
							gd.setCreate_time(date);
						}
						// 保存数据
						boolean resultflag = groundOtherJsonService.saveList(listgd);
						System.out.println("数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}

				} else {
					// 请求接口成功的  但是 返回失败的处理

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有地面数据");
				}
				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
			
		} catch (IOException e) {
			logger.error(" 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		
	}

	@Override
	public void saveGroundTemJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "groundTem" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\groundTem数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestThereDataApi(requestapi, querylog);
		}

		try {
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				GroundTemResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundTemResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 地面数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int gdCount = 0;

					// 取得实际数据
					List<GroundTemJson> listgd = jsonObject.getGroundTemJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						gdCount = listgd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(gdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (gdCount > 0) {
						// 循环加工数据
						Iterator<GroundTemJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							GroundTemJson gd = iter.next();
							// 设置主键id
							gd.setGround_tem_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);

							// 数据保存时间
							gd.setCreate_time(date);
						}
						// 保存数据
						boolean resultflag = groundTemJsonService.saveList(listgd);
						System.out.println("数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}

				} else {
					// 请求接口成功的  但是 返回失败的处理

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有地面数据");
				}
				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
			
		} catch (IOException e) {
			logger.error(" 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		
	}

	@Override
	public void saveRadiationMinJson(QueryLog querylog, RequestApi requestapi, boolean initFalg) throws Exception {
		String path = fileSaveDirPrefix + File.separatorChar;

		String filepath = "radiationMin" + File.separatorChar + WeatherDataUtil.getFilePath(querylog);

		File file = new File(path + filepath);

		String result = "";

		if ("true".equals(moniTest)) {
			// 本地测试
			FileReader fileReader = new FileReader("E:\\星飓力公司\\气象局\\radiationMin数据.txt");
			result = StringUtil.getJsonTxt(fileReader);
		} else {
			// 不同的 请求类型 使用不同的 处理方法
			// 请求api 的处理
			result = WeatherDataUtil.requestTimesDataApi(requestapi, querylog);
		}

		try {
			
			if(result !=null){
				// 保存数据 到 txt 文档中 自动建文件外两层目录
				WeatherDataUtil.saveResultTxtFile(result, file);
				RadiationMinResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<RadiationMinResponseJson>() {
				});

				// 获取返回码
				String returnCode = jsonObject.getReturnCode();
				if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)
						|| RequestApiCodeEnum.SUCCESS_FALSE.getValue().equals(returnCode)) {
					// 请求成功的处理

					// 保存一份 回应 常量值 然后在保存 地面数据
					if (initFalg) {
						ReponseConstant rcs = new ReponseConstant();
						rcs.setReponseConstantId(IdWorker.getIdStr());
						rcs.setCreateTime(DataUtil.getCurrenTimestamp());
						rcs.setRequestParams(jsonObject.getRequestParams());
						rcs.setFieldNames(jsonObject.getFieldNames());
						rcs.setFieldUnits(jsonObject.getFieldUnits());
						rcs.setRequestApiId(requestapi.getRequest_api_id());
						rcs.setQueryLogId(querylog.getQuery_log_id());
						// 保存数据
						reponseConstantMapper.insert(rcs);
					}

					int gdCount = 0;

					// 取得实际数据
					List<RadiationMinJson> listgd = jsonObject.getRadiationMinJson();

					if (RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)) {

						gdCount = listgd.size();
					}

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.SUCCESS.getValue());

					ql.setRequest_des(ResultStausEnum.SUCCESS.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));

					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setRow_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					ql.setActual_count(gdCount);
					ql.setFile_path(filepath);

					queryLogMapper.updateById(ql);

					Timestamp date = DataUtil.getCurrenTimestamp();

					if (gdCount > 0) {
						// 循环加工数据
						Iterator<RadiationMinJson> iter = listgd.iterator();
						while (iter.hasNext()) {
							RadiationMinJson gd = iter.next();
							// 设置主键id
							gd.setRadiation_min_id(IdWorker.getIdStr());
							// 查询id
							gd.setData_query_id(querylog.getQuery_log_id());
							// 请求的数据类型id
							gd.setRequest_api_id(requestapi.getRequest_api_id());

							// 资料时间
							Timestamp filedate = WeatherDataUtil.getTimestamp(gd.getYear(), gd.getMon(), gd.getDay(),
									gd.getHour(), gd.getMin());
							gd.setData_time(filedate);

							// 数据保存时间
							gd.setCreate_time(date);
						}
						// 保存数据
						boolean resultflag = radiationMinJsonService.saveList(listgd);
						System.out.println("数据保存状态：" + resultflag);
						// 如果 保存 失败 是否 更新数据为 保存失败
					}

				} else {
					// 请求接口成功的  但是 返回失败的处理

					// 更新查询数据表 填入回应信息
					QueryLog ql = new QueryLog();
					ql.setQuery_log_id(querylog.getQuery_log_id());
					ql.setRequest_data_status(ResultStausEnum.FAILE.getValue());
					ql.setRequest_des(ResultStausEnum.FAILE.getMessage());
					
					ql.setReturn_message(WeatherDataUtil.getRequestApiCodeEnumMessageByValue(jsonObject.getReturnCode()));
					
					ql.setReturn_code(jsonObject.getReturnCode());
					ql.setActual_count(Integer.valueOf(jsonObject.getRowCount()));
					ql.setColount(Integer.valueOf(jsonObject.getColCount()));
					ql.setRequest_time(jsonObject.getRequestTime());
					ql.setResponse_time(jsonObject.getResponseTime());
					ql.setTake_time(jsonObject.getTakeTime());
					// 实际返回 数量值
					// ql.setActualCount(jsonObject.getGroundData().size());
					// ql.setFilePath(filepath);

					queryLogMapper.updateById(ql);

					logger.error("本次请求数据返回码正常，但是没有地面数据");
				}
				
			}else{
				// 更新查询数据表 填入回应信息
				QueryLog ql = new QueryLog();
				ql.setQuery_log_id(querylog.getQuery_log_id());
				ql.setRequest_data_status(ResultStausEnum.TIMEOUT.getValue());
				ql.setRequest_des(ResultStausEnum.TIMEOUT.getMessage());

				queryLogMapper.updateById(ql);
			}
			
			
		} catch (IOException e) {
			logger.error(" 请求后保存失败:quertylogid=" + querylog.getQuery_log_id());
			e.printStackTrace();
		}

		
	}

	@Override
	public Map<String, Object> createRadiationMinQuerylog(RequestApi requestapi, WeatherTask wt) throws Exception {
		Map<String, Object> map = new HashMap<String, Object>();

		boolean stopTaskFlag = false;
		map.put("initFlag", false);
		map.put("stopTaskFlag", stopTaskFlag);

		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimerangeEnd(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		if (listDate.size() == 1 && successCount > 0) {

			Date maxTimesdate = listDate.get(0);
			String maxTimesStr = DataUtil.formatDate(maxTimesdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByadt(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxTimesStr);

			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);

				// 获取到上一次 的查询 成功  最后 一个 时间点的时间
				Timestamp timesStart = ql.getTimerange_end();

				Timestamp startDate=WeatherDataUtil.afterMin(timesStart, 1);
				Timestamp endDate=startDate;
				// 时间个数 例如 为2 表示两个个时间
				int increment = requestapi.getIncrement();

				if (!(increment > 0)) {
					logger.error(" 辐射分钟requestapi 未配置 时间时间个数，默认赋值为2,即每次查询两个时间的数据");
					increment = 2;
				}

				// 保存时间 下一步 循环查询querylog数据
				List<String> listTimes = new ArrayList<String>();


				Date befor15Date = new Date();
				
				// 计算xx 天前的时间   到距今 15天的 时间  不在抓取历史数据
				befor15Date=WeatherDataUtil.afterDate(befor15Date, requestapi.getBefor_day_stop());
				for (int i = 0; i < increment; i++) {

					Timestamp nextTime = WeatherDataUtil.afterMin(timesStart, 1);

					String nextTimeStrs=DateUtil.DateToString(nextTime, "yyyyMMddHHmmss");
					// 如果下一个 时间 超过今天 或 下一个 时间的年月日 =今天的年月日
					// 需要 返回停止定时任务 标识
					if (nextTime.after(befor15Date) || WeatherDataUtil.sameDate(nextTime, befor15Date)) {
						stopTaskFlag = true;
						map.put("stopTaskFlag", stopTaskFlag);
						// 跳出 for循环
						break;

					}

					listTimes.add(nextTimeStrs);
					timesStart = nextTime;
					endDate=nextTime;
				}

				if (listTimes.size() > 0) {
					
						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());
                        qul.setTimerange_start(startDate);
                        qul.setTimerange_end(endDate);
						qul.setTimes(WeatherDataUtil.getTimesStr(listTimes));
						qul.setTimesStr(WeatherDataUtil.getTimesStr(listTimes));
						qul.setTimerangeStartStr(DateUtil.DateToString(startDate, "yyyyMMddHHmmss"));
						qul.setTimerangeEndStr(DateUtil.DateToString(endDate, "yyyyMMddHHmmss"));
						
						qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(startDate, endDate));

						
						qul.setTimerangeStartStr(DateUtil.DateToString(startDate, "yyyyMMddHHmmss"));
						qul.setTimerangeEndStr(DateUtil.DateToString(endDate, "yyyyMMddHHmmss"));
						int requsultTemp = queryLogMapper.insert(qul);
						
						if (requsultTemp > 0) {
							map.put("querylog", qul);
							return map;
						}
						else {
							logger.error(" 请求数据(QueryLog)保存失败");
							throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
						}
				} else {
					return null;
				}

			} else {
				logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
				throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
			}
		} else {
			// 需要初始化数据
			// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存
			// 获取初始化参数
			Map<String, Object> mp = this.inintRadiationMinCreateQuerylog(requestapi, wt);
			return mp;
		}
	}

	@Override
	public Map<String, Object> inintRadiationMinCreateQuerylog(RequestApi requestapi, WeatherTask wt) throws Exception {
		Map<String, Object> map = new HashMap<String, Object>();

		map.put("initFlag", true);
		map.put("stopTaskFlag",false);
		// 需要初始化数据
		// 从requestapi 中 取初始化参数 在产生 querylog数据 进行 数据请求并保存

		// 获取初始化参数
		RequestApi reqapi = requestApiMapper.selectById(requestapi.getRequest_api_id());
		if (reqapi == null) {
			throw new WeatherException(RequestApiCodeEnum.ERROR_9001, requestapi.getRequest_api_id());
		}
		QueryLog qul = new QueryLog();
		String queryLogId = IdWorker.getIdStr();
		qul.setQuery_log_id(queryLogId);

		qul.setCreate_time(DataUtil.getCurrenTimestamp());

		qul.setRequest_api_id(requestapi.getRequest_api_id());

		// 查询时间 初始化 一个小时的量
		qul.setTimes(WeatherDataUtil.getTimestampStr(reqapi.getTimes_init()));
		qul.setTimesStr(WeatherDataUtil.getTimestampStr(reqapi.getTimes_init()));

		qul.setTimerange_start(reqapi.getTime_start());
		qul.setTimerange_end(reqapi.getTime_end());
		qul.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(reqapi.getTimes_init(), reqapi.getTimes_init()));

		qul.setTimerangeStartStr(DateUtil.DateToString(reqapi.getTime_start(), "yyyyMMddHHmmss"));
		qul.setTimerangeEndStr(DateUtil.DateToString(reqapi.getTime_end(), "yyyyMMddHHmmss"));
		
		int request = queryLogMapper.insert(qul);

		if (request > 0) {
			map.put("querylog", qul);
			return map;
		} else {
			logger.error(" 辐射分钟  数据 ,初始化Querylog数据保存失败");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9002, requestapi.getRequest_api_id());
		}

	}

	@Override
	public QueryLog createRadiationMinQuerylogTimin(RequestApi requestapi, WeatherTask wt) throws Exception {
		/*// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimes(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());

		// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
				ResultStausEnum.SUCCESS.getValue());*/
		
		// 获取最大的 的 请求时间 已发送请求数据成功的 数据
		List<Date> listDate = queryLogMapper.getMaxTimerangeEnd(requestapi.getRequest_api_id(),
						ResultStausEnum.SUCCESS.getValue());

				// 统计已发送请求的 数据成功的数量
		int successCount = queryLogMapper.getCountByStatusAndId(requestapi.getRequest_api_id(),
						ResultStausEnum.SUCCESS.getValue());
		if (listDate.size() == 1 && successCount > 0) {

			Date maxTimesdate = listDate.get(0);
			String maxTimesStr = DataUtil.formatDate(maxTimesdate, "yyyyMMddHHmmss");

			List<QueryLog> listql = queryLogMapper.getQueryLogByadt(requestapi.getRequest_api_id(),
					ResultStausEnum.SUCCESS.getValue(), maxTimesStr);
			QueryLog beforQl=null;
			if (listql.size() == 1) {

				// 获取的 最后一次成功的 querylog数据
				QueryLog ql = listql.get(0);
				beforQl=ql;
				// 获取到上一次 的查询 成功时间
				Timestamp timesStart = ql.getTimerange_end();

				Timestamp startDate=WeatherDataUtil.afterMin(timesStart, 1);
				Timestamp endDate=startDate;
				// 时间个数 例如 为2 表示 查询两个时间点的数据 格式： 20200730000000,20200731000000
				int increment = requestapi.getIncrement();

				if (!(increment > 0)) {
					logger.error("辐射 分钟 数据  requestapi 未配置 时间时间个数，默认赋值为2,即每次查一个时间点的数据");
					increment = 2;
				}

				// 保存时间 下一步 循环查询querylog数据
				List<String> listTimes = new ArrayList<String>();


				
				
				Timestamp startTime=WeatherDataUtil.afterMin(timesStart, 1);
				
				//昨天的  0时0分0秒时间
				Date endTime=WeatherDataUtil.yesterday00();
				
				//下一个 有数据的 远端 时间点
				Date  lastEndTime=WeatherDataUtil.getLastEndTimeRadiationData(new Date(startTime.getTime()), endTime, requestapi);
				
				if(lastEndTime ==null){
					logger.info(" ===  不存在下一个 有数据的时间点   =============");
					return null;
				}
				
				
				
				// 加工时间条件 将时间条件 放集合里
				while(true){
					String nextTimeStrs=DateUtil.DateToString(startTime, "yyyyMMddHHmmss");
					listTimes.add(nextTimeStrs);
					startTime =WeatherDataUtil.afterMin(timesStart, 1);
					if((new Date(startTime.getTime())).after(lastEndTime) || WeatherDataUtil.sameDate(new Date(startTime.getTime()), lastEndTime)){
						break;
					}
				}

				

				if (listTimes.size() > 0) {

						QueryLog qul = new QueryLog();
						String queryLogId = IdWorker.getIdStr();
						qul.setQuery_log_id(queryLogId);
						qul.setCreate_time(DataUtil.getCurrenTimestamp());
						qul.setRequest_api_id(requestapi.getRequest_api_id());

						qul.setTimerange_start(startDate);
                        qul.setTimerange_end(endDate);
						qul.setTimes(WeatherDataUtil.getTimesStr(listTimes));
						qul.setTimesStr(WeatherDataUtil.getTimesStr(listTimes));
						
						qul.setTimerangeStartStr(DateUtil.DateToString(startDate, "yyyyMMddHHmmss"));
						qul.setTimerangeEndStr(DateUtil.DateToString(endDate, "yyyyMMddHHmmss"));
						
						

						int requsultTemp = queryLogMapper.insert(qul);
						if (requsultTemp > 0) {
							return qul;
						}else {
							logger.error(" 请求数据(QueryLog)保存失败");
							throw new WeatherException(RequestApiCodeEnum.ERROR_9002);
						}

					}
				} else {

					logger.info("===========今日无新数据 需要抓取  =========上一次数据请求成功信息：querylogid=" + beforQl.getQuery_log_id()
							+ ",查询时间:" + beforQl.getTimerangeStartStr() + "-" + beforQl.getTimerangeEndStr());

					QueryLog qul = new QueryLog();
					String queryLogId = IdWorker.getIdStr();
					qul.setQuery_log_id(queryLogId);
					qul.setCreate_time(DataUtil.getCurrenTimestamp());
					qul.setRequest_api_id(requestapi.getRequest_api_id());

					qul.setRequest_data_status(ResultStausEnum.TWO.getValue());
					qul.setRequest_des(ResultStausEnum.TWO.getMessage() + "上一次成功请求的id:" + beforQl.getQuery_log_id());

					queryLogMapper.insert(qul);

					return null;
				}

		} else {
			logger.error(" 没有查询到  最新一次 请求成功的  query_log 数据");
			throw new WeatherException(RequestApiCodeEnum.ERROR_9004, requestapi.getRequest_api_id());
		}
		return null;
	}
	
	
}